System and method for removing a storage server in a distributed column chunk data store

ABSTRACT

An improved system and method for removing a storage server in a distributed column chunk data store is provided. A distributed column chunk data store may be provided by multiple storage servers operably coupled to a network. A storage server provided may include a database engine for partitioning a data table into the column chunks for distributing across multiple storage servers, a storage shared memory for storing the column chunks during processing of semantic operations performed on the column chunks, and a storage services manager for striping column chunks of a partitioned data table across multiple storage servers. Any data table may be flexibly partitioned into column chunks using one or more columns with various partitioning methods. Storage servers may then be removed and column chunks may be redistributed among the remaining storage servers in the column chunk data store.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present invention is related to the following United States patentapplications, filed concurrently herewith and incorporated herein intheir entireties:

“System and Method for Updating Data in a Distributed Column Chunk DataStore,” U.S. patent application Ser. No. 11/311,811;

“System and Method for Adding a Storage Server to a Distributed ColumnChunk Data Store,” U.S. patent application Ser. No. 11/305,916;

“System and Method for Recovering from Failure of a Storage Server in aDistributed Column Chunk Data Store,” U.S. patent application Ser. No.11/311,510;

“System for Query Processing of Column Chunks in a Distributed ColumnChunk Data Store,” U.S. patent application Ser. No. 11/305,998;

“System of a Hierarchy of Servers for Query Processing of Column Chunksin a Distributed Column Chunk Data Store,” U.S. patent application Ser.No. 11/311,825;

“Method for Query Processing of Column Chunks in a Distributed ColumnChunk Data Store,” U.S. patent application Ser. No. 11/305,997;

“Method Using Query Processing Servers for Query Processing of ColumnChunks in a Distributed Column Chunk Data Store,” U.S. patentapplication Ser. No. 11/305,915; and

“Method Using a Hierarchy of Servers for Query Processing of ColumnChunks in a Distributed Column Chunk Data Store,” U.S. patentapplication Ser. No. 11/305,958.

The present invention is also related to the following copending UnitedStates Patent Applications filed Sep. 13, 2005, assigned to the assigneeof the present invention, and hereby incorporated by reference in theirentireties:

“System for a Distributed Column Chunk Data Store,” U.S. patentapplication Ser. No. 11/226,606;

“Method for a Distributed Column Chunk Data Store,” U.S. patentapplication Ser. No. 11/226,667; and

“System and Method for Compression in a Distributed Column Chunk DataStore,” U.S. patent application Ser. No. 11/226,668.

FIELD OF THE INVENTION

The invention relates generally to computer systems, and moreparticularly to an improved system and method for removing a storageserver in a distributed column chunk data store.

BACKGROUND OF THE INVENTION

Distributed storage systems implemented either as a distributed databaseor a distributed file system fail to scale well for data mining andbusiness intelligence applications that may require fast and efficientretrieval and processing of large volumes of data. Distributed databasesfor large volumes of data, perhaps on the order of terabytes, may betraditionally implemented across several servers, each designed to hosta portion of a database and typically storing a particular table data.In some implementations, such a system may also store a horizontallypartitioned table of data on one or more servers. For instance, thetechnique known as horizontal partitioning may be used to store a subsetof rows of data in a table resident on a storage server. Queries forretrieving data from the distributed storage system may then beprocessed by retrieving rows of data having many associated columns ofdatum for which only one or few columns may be needed to process thequery. As a result, the storage and retrieval of data in these types ofsystems is inefficient, and consequently such systems do not scale wellfor handling terabytes of data.

Typical transaction processing systems using a distributed databaselikewise fail to scale well for data mining and business intelligenceapplications. Such systems may characteristically have slower processingspeed during a failed transaction. During transaction processing afailed transaction may become abandoned and the database may be rolledback to a state prior to the failed transaction. Such databaseimplementations prove inefficient for updating large data sets on theorder of gigabytes or terabytes.

Distributed file systems are also inadequate for storage and retrievalof data for data mining and business intelligence applications. First ofall, distributed file systems may only provide low-level storageprimitives for reading and writing data to a file. In general, suchsystems fail to establish any semantic relationships between data andfiles stored in the file system. Unsurprisingly, semantic operations fordata storage and retrieval such as redistributing data, replacingstorage, and dynamically adding additional storage are not available forsuch distributed file systems.

What is needed is a way for providing data storage, query processing andretrieval for large volumes of data perhaps in the order of hundreds ofterabytes for data warehousing, data mining and business intelligenceapplications. Any such system and method should allow the use of commonstorage components without requiring expensive fault-tolerant equipment.

SUMMARY OF THE INVENTION

Briefly, the present invention may provide a system and method forremoving a storage server in a distributed column chunk data store. Adistributed column chunk data store may be provided by multiple storageservers operably coupled to a network. A client executing an applicationmay also be operably coupled to the network. A storage server providedmay include a database engine for partitioning a data table into columnchunks for distributing across multiple storage servers, a storageshared memory for storing the column chunks during processing ofsemantic operations performed on the column chunks, and a storageservices manager for striping column chunks of a partitioned data tableacross multiple storage servers.

The database engine may include a loading services module for importingdata into a data table partitioned into column chunks, a query servicesmodule for receiving requests for processing data stored as columnchunks striped across multiple storage servers, a metadata servicesmodule for managing metadata about the column chunks striped across theplurality of storage servers, a transaction services module formaintaining the integrity of the information about semantic operationsperformed on the column chunks, and a storage services proxy module forreceiving storage services requests and sending the requests forexecution by the storage services manager. The storage services managermay include compression services for compressing the column chunksbefore storing to the column chunk data store and transport services forsending one or more compressed or uncompressed column chunks to anotherstorage server.

Advantageously, a data table may be flexibly partitioned into columnchunks using one or more columns as a key with various partitioningmethods, including range partitioning, list partitioning, hashpartitioning, and/or combinations of these partitioning methods. Theremay also be a storage policy for specifying how to partition a datatable for distributing column chunks across multiple servers, includingthe number of column chunks to create. The storage policy may alsospecify the desired level of redundancy of column chunks for recoveryfrom failure of one or more storage servers storing the column chunks.The storage policy may also specify how to assign column chunks toavailable storage servers. There may be a storage policy for each datatable that may be different from the storage policy for another datatable and may specify a different method for partitioning the data tableinto column chunks, a different level of redundancy for recovery fromfailure of one or more servers, and/or a different method fordistributing the column chunks among the multiple storage servers.

The invention may also support the removal of one or more storageservers from the distributed column chunk data store. Metadata may beupdated for distributing column chunks from the server to be removed tothe remaining storage servers of the column chunk data store. Then thecolumn chunks may be migrated from the server to be removed to one ormore of the remaining storage servers of the column chunk data store,and the storage server may be subsequently removed. In an embodiment,the parity of column chunks calculated for supporting a level ofredundancy specified in a storage policy for recovery from failure ofone or more storage servers may be recomputed when the number of storageservers remaining after removal of a storage server may no longer begreater than the number of column chunks used to compute the paritycolumn chunks.

Other advantages will become apparent from the following detaileddescription when taken in conjunction with the drawings, in which:

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram generally representing a computer system intowhich the present invention may be incorporated;

FIG. 2 is a block diagram generally representing an exemplaryarchitecture of system components for a column chunk data store, inaccordance with an aspect of the present invention;

FIG. 3 is a flowchart generally representing the steps undertaken in oneembodiment for storing column chunks among multiple storage servers inthe column chunk data store, in accordance with an aspect of the presentinvention;

FIG. 4 is a flowchart generally representing the steps undertaken in oneembodiment for partitioning a data table into column chunks, inaccordance with an aspect of the present invention;

FIGS. 5A and 5B are exemplary illustrations generally depicting logicalrepresentations of column chunks of a partitioned data table stripedacross multiple storage servers with parity for recovering from failureof a server, in accordance with an aspect of the present invention;

FIG. 6 is a flowchart generally representing the steps undertaken in oneembodiment for removing a storage server in the column chunk data store,in accordance with an aspect of the present invention;

FIG. 7 is a flowchart generally representing the steps undertaken in oneembodiment for recomputing parity of column chunks for a specified levelof redundancy upon removal of a storage server in the column chunk datastore, in accordance with an aspect of the present invention; and

FIGS. 8A and 8B are exemplary illustrations generally depicting logicalrepresentations of column chunks of a partitioned data table stripedacross multiple storage servers after removal of a storage server, inaccordance with an aspect of the present invention.

DETAILED DESCRIPTION

Exemplary Operating Environment

FIG. 1 illustrates suitable components in an exemplary embodiment of ageneral purpose computing system. The exemplary embodiment is only oneexample of suitable components and is not intended to suggest anylimitation as to the scope of use or functionality of the invention.Neither should the configuration of components be interpreted as havingany dependency or requirement relating to any one or combination ofcomponents illustrated in the exemplary embodiment of a computer system.The invention may be operational with numerous other general purpose orspecial purpose computing system environments or configurations.

The invention may be described in the general context ofcomputer-executable instructions, such as program modules, beingexecuted by a computer. Generally, program modules include routines,programs, objects, components, data structures, and so forth, whichperform particular tasks or implement particular abstract data types.The invention may also be practiced in distributed computingenvironments where tasks are performed by remote processing devices thatare linked through a communications network. In a distributed computingenvironment, program modules may be located in local and/or remotecomputer storage media including memory storage devices.

With reference to FIG. 1, an exemplary system for implementing theinvention may include a general purpose computer system 100. Componentsof the computer system 100 may include, but are not limited to, a CPU orcentral processing unit 102, a system memory 104, and a system bus 120that couples various system components including the system memory 104to the processing unit 102. The system bus 120 may be any of severaltypes of bus structures including a memory bus or memory controller, aperipheral bus, and a local bus using any of a variety of busarchitectures. By way of example, and not limitation, such architecturesinclude Industry Standard Architecture (ISA) bus, Micro ChannelArchitecture (MCA) bus, Enhanced ISA (EISA) bus, Video ElectronicsStandards Association (VESA) local bus, and Peripheral ComponentInterconnect (PCI) bus also known as Mezzanine bus.

The computer system 100 may include a variety of computer-readablemedia. Computer-readable media can be any available media that can beaccessed by the computer system 100 and includes both volatile andnonvolatile media. For example, computer-readable media may includevolatile and nonvolatile computer storage media implemented in anymethod or technology for storage of information such ascomputer-readable instructions, data structures, program modules orother data. Computer storage media includes, but is not limited to, RAM,ROM, EEPROM, flash memory or other memory technology, CD-ROM, digitalversatile disks (DVD) or other optical disk storage, magnetic cassettes,magnetic tape, magnetic disk storage or other magnetic storage devices,or any other medium which can be used to store the desired informationand which can accessed by the computer system 100. Communication mediamay also embodies computer-readable instructions, data structures,program modules or other data in a modulated data signal such as acarrier wave or other transport mechanism and includes any informationdelivery media. The term “modulated data signal” means a signal that hasone or more of its characteristics set or changed in such a manner as toencode information in the signal. For instance, communication mediaincludes wired media such as a wired network or direct-wired connection,and wireless media such as acoustic, RF, infrared and other wirelessmedia.

The system memory 104 includes computer storage media in the form ofvolatile and/or nonvolatile memory such as read only memory (ROM) 106and random access memory (RAM) 110. A basic input/output system 108(BIOS), containing the basic routines that help to transfer informationbetween elements within computer system 100, such as during start-up, istypically stored in ROM 106. Additionally, RAM 110 may contain operatingsystem 112, application programs 114, other executable code 116 andprogram data 118. RAM 110 typically contains data and/or program modulesthat are immediately accessible to and/or presently being operated on byCPU 102.

The computer system 100 may also include other removable/non-removable,volatile/nonvolatile computer storage media. By way of example only,FIG. 1 illustrates a hard disk drive 122 that reads from or writes tonon-removable, nonvolatile magnetic media, and storage device 134 thatmay be an optical disk drive or a magnetic disk drive that reads from orwrites to a removable, a nonvolatile storage medium 144 such as anoptical disk or magnetic disk. Other removable/non-removable,volatile/nonvolatile computer storage media that can be used in theexemplary computer system 100 include, but are not limited to, magnetictape cassettes, flash memory cards, digital versatile disks, digitalvideo tape, solid state RAM, solid state ROM, and the like. The harddisk drive 122 and the storage device 134 may be typically connected tothe system bus 120 through an interface such as storage interface 124.

The drives and their associated computer storage media, discussed aboveand illustrated in FIG. 1, provide storage of computer-readableinstructions, executable code, data structures, program modules andother data for the computer system 100. In FIG. 1, for example, harddisk drive 122 is illustrated as storing operating system 112,application programs 114, other executable code 116 and program data118. A user may enter commands and information into the computer system100 through an input device 140 such as a keyboard and pointing device,commonly referred to as mouse, trackball or touch pad tablet, electronicdigitizer, or a microphone. Other input devices may include a joystick,game pad, satellite dish, scanner, and so forth. These and other inputdevices are often connected to CPU 102 through an input interface 130that is coupled to the system bus, but may be connected by otherinterface and bus structures, such as a parallel port, game port or auniversal serial bus (USB). A display 138 or other type of video devicemay also be connected to the system bus 120 via an interface, such as avideo interface 128. In addition, an output device 142, such as speakersor a printer, may be connected to the system bus 120 through an outputinterface 132 or the like computers.

The computer system 100 may operate in a networked environment using anetwork 136 to one or more remote computers, such as a remote computer146. The remote computer 146 may be a personal computer, a server, arouter, a network PC, a peer device or other common network node, andtypically includes many or all of the elements described above relativeto the computer system 100. The network 136 depicted in FIG. 1 mayinclude a local area network (LAN), a wide area network (WAN), or othertype of network. Such networking environments are commonplace inoffices, enterprise-wide computer networks, intranets and the Internet.In a networked environment, executable code and application programs maybe stored in the remote computer. By way of example, and not limitation,FIG. 1 illustrates remote executable code 148 as residing on remotecomputer 146. It will be appreciated that the network connections shownare exemplary and other means of establishing a communications linkbetween the computers may be used.

Removing a Storage Server in a Distributed Column Chunk Data Store

The present invention is generally directed towards a system and methodfor removing a storage server in a distributed column chunk data store.More particularly, the present invention provides multiple storageservers operably coupled by a network for storing distributed columnchunks of partitioned data tables. Any data table may be partitionedinto column chunks and the column chunks may then be distributed forstorage among multiple storage servers. To do so, a data table may beflexibly partitioned into column chunks by applying various partitioningmethods using one or more columns as a key, including rangepartitioning, list partitioning, hash partitioning, and/or combinationsof these partitioning methods. Subsequently, one or more storage serversmay be removed from the distributed column chunk data store. Metadatamay be updated for distributing column chunks from the server to beremoved to the remaining storage servers of the column chunk data store.Then the column chunks may be migrated from the server to be removed toone or more of the remaining storage servers of the column chunk datastore, and the storage server may be removed.

As will be seen, the parity of column chunks calculated for supportingthe level of redundancy specified in a storage policy for recovery fromfailure of one or more storage servers may be recomputed when the numberof storage servers remaining after removal of a storage server may nolonger be greater than the number of column chunks used to compute theparity column chunks. As will be understood, the various block diagrams,flow charts and scenarios described herein are only examples, and thereare many other scenarios to which the present invention will apply.

Turning to FIG. 2 of the drawings, there is shown a block diagramgenerally representing an exemplary architecture of system componentsfor a distributed column chunk data store. Those skilled in the art willappreciate that the functionality implemented within the blocksillustrated in the diagram may be implemented as separate components orthe functionality of several or all of the blocks may be implementedwithin a single component. For example, the functionality for thestorage services manager 226 may be included in the same component asthe database engine 208. Or the functionality of transport services 232may be implemented as a separate component.

As used herein, a column chunk data store may mean a large distributedsystem of operably coupled storage servers, each capable of storingcolumn chunks. In various embodiments, one or more applications 202 maybe operably coupled to one or more storage servers 206 by a network 204.The network 204 may be any type of network such as a local area network(LAN), a wide area network (WAN), or other type of network. In general,an application 202 may be any type of executable software code such as akernel component, an application program, a linked library, an objectwith methods, and so forth. In one embodiment, an application mayexecute on a client computer or computing device, such as computersystem environment 100 of FIG. 1 which may be operably coupled to one ormore storage servers 206 by the network 204. An application 202 mayinclude functionality for querying the column chunk data store toretrieve information for performing various data mining or businessintelligence operations, such as computing segment membership,performing some aggregation of data including summarization, and soforth.

A storage server 206 may be any type of computer system or computingdevice such as computer system environment 100 of FIG. 1. The storageserver may provide services for performing semantic operations on columnchunks such as redistributing data, replacing storage, and/or addingstorage and may use lower-level file system services in carrying outthese semantic operations. A storage server 206 may include a databaseengine 208 storage shared memory 222, and a storage services manager226. Each of these modules may also be any type of executable softwarecode such as a kernel component, an application program, a linkedlibrary, an object with methods, or other type of executable softwarecode.

The database engine 208 may be responsible, in general, forcommunicating with an application 202, communicating with the storageserver to satisfy client requests, accessing the column chunk datastore, and communicating with the storage services manager 226 forexecution of storage operations, including accessing column chunks 224in storage shared memory 220. The database engine 208 may include loadservices 210, query services 212, metadata services 214, transactionservices 216 and a storage services proxy 218. Load services 210 may beused for importing data into the data tables. Query services 212 mayprocess received queries by retrieving the data from the storageservices manager 226 and processing the retrieved data. The loadservices 210 and query services 212 may communicate with the metadataservices 214 and transaction services 216 using a communicationmechanism such as inter-process communication. Each of these servicesmay in turn communicate with the storage services proxy 218 to requestservices such as retrieving and loading column chunks into storageshared memory 220. The storage services proxy 218 may receive storageread and write requests and pass the requests off to the storageservices manager 226 to execute the request.

The metadata services 214 may provide services for the configuration ofthe storage servers and may manage metadata for the database engine andthe column chunk data store. The metadata may include, for example, datatables that reflect the current state of the system including the nameof each server configured in the system, the load on each server, thebandwidth between servers, and many other variables maintained in thedata tables. There may be dynamically updated tables and static tablesof data. Static tables of data may include configuration tables, thedefined logical tables, policies that may apply for partitioning thedata table and storage distribution, and so forth. Some tables, such asconfiguration tables, may be generated dynamically by the system basedupon system configuration. The metadata services 214 may includeservices to dynamically update metadata, such as configuration tables.In addition, metadata services 214 may include services to add or updatefixed metadata such as adding new logical data table definitions orupdating an existing logical data table definition.

The transaction services 216 may be responsible for maintaining activetransactions in the system and may provide various services such asidentifying and loading the appropriate version of column chunks. Thetransaction services 216 can also notify metadata services to update orcommit metadata relating to a specific transaction. Generally, atransaction may include semantic operations that modify the system orthat may be performed on data, including data loading, dataoptimization, data retrieval, updating existing data table, creating newtables, modifying the data schema, creating a new storage policy,partitioning data tables, recording the column chunk distribution instorage servers, and so forth. For each transaction such asincrementally updating a data table, there may be an indication of astart of a transaction and end of transaction when the update of thedata table completes. Other examples of transactions may be executing aquery, including generating intermediate data tables or other datatables, or optimizing storage of column chunks. To do so, the queryservices may use transaction services to process a query and the storageservices manager may use transactions services while optimizing columnchunk storage.

The storage shared memory 220 of the storage server 206 may include lowlevel metadata 222 and column chunks 224. The low level metadata mayinclude information about physical storage, such as the file name andserver name where a column chunk may be located, what the compressedsize of a column chunk may be, what the uncompressed size of a columnchunk may be, what the checksum on a column chunk may be for verifyingthat the column chunk is not corrupted on the disk storage, and soforth. The storage services manager 226 may generate low level metadata222 by using the metadata such as policies, server configurations,resources available in metadata to generate physical storage for columnchunks.

The storage services manager 226 may include a local storage servicesmanager 228 that may provide compression services 230 and transportservices 232. The compression services 230 may perform data domaincompression and decompression of column chunks. For instance, datadomain compression may be performed before storing the column chunks instorage and data domain decompression may be performed upon retrievingthe column chunks from storage. Transports services 232 may provideservices to transfer column chunks between servers. In one embodiment, alow level protocol may be employed upon a TCP/IP protocol stack forsending and receiving column chunks.

There are many applications which may use the present invention forstoring large volumes of detailed data over long periods of time. Datamining, segmentation and business intelligence applications are examplesamong these many applications. FIG. 3 presents a flowchart generallyrepresenting the steps undertaken in one embodiment for storing columnchunks among multiple storage servers in the column chunk data store. Atstep 302, a data table may be partitioned into column chunks. As usedherein, a column chunk may mean a column of a data table partitionedusing one or more columns as a key. Any type of data table may bepartitioned into column chunks. For instance, a large fact tablecapturing transactions of users logging into a website may bepartitioned into column chunks. In one embodiment, the data table may bepartitioned into column chunks by performing column-wise partitioningwhereby a partition may be specified by a set of columns. In anotherembodiment, a combination of some data table partitioning technique andcolumn-wise partitioning may be performed. In this embodiment, the datatable may be first partitioned into several data tables and thencolumn-wise partitioning may be performed on the resulting data tablesto create column chunks. To do so, those skilled in the art willappreciate that a data table may be partitioned into column chunks usingany number of partitioning techniques such as range partitioning byspecifying a range of value for a partitioning key, list partitioning byspecifying a list of values for a partitioning key, hash partitioning byapplying hashing to a partitioning key, combinations of thesepartitioning techniques, and other partitioning techniques known tothose skilled in the art.

Once the data table may be partitioned into column chunks, the storageserver may distribute the column chunks among multiple storage serversat step 304. For example, the column chunks of the data table may bestriped across multiple storage servers. In one embodiment, each columnchunk of the data table may be assigned to an available storage serverusing any assignment method including round robin order. In variousembodiments, column chunks of a data table may be striped acrossmultiple storage servers. As used herein, column chunk striping meansstriping column chunks of a data table across multiple storage servers.Any level of redundancy may be implemented in distributing the columnchunks for recovery of one or more failed servers. For example, columnchunk parity may be calculated and stored to enable recovery fromfailure of one server. In an embodiment, a bitwise XOR operation may beperformed on two column chunks to create a parity column chunk.Additional bitwise XOR operations may be performed with a parity columnchunk and another binary representation of a column chunk to compute aparity column chunk for three column chunks. The resulting parity columnchunk may then be assigned to an available server that does not storeone of the three column chunks used to make the parity column chunk. Inthis way, any number of parity column chunks may be calculated andassigned to storage servers for recovery from failure of one or morestorage servers. It should be noted that prior to performing a bitwiseXOR operation on two column chunks of unequal length, the shorter columnchunk may be padded with 0's until it become of equal length with theother column chunk.

Once the distribution of column chunks among the multiple storageservers may be determined, the column chunks may be stored on theirassigned servers at step 306. After the column chunks have been stored,processing may be finished for storing column chunks among multiplestorage servers in the column chunk data store.

FIG. 4 presents a flowchart generally representing the steps undertakenin one embodiment for partitioning a data table into column chunks. Atstep 402, a policy for partitioning the data table into column chunksmay be accessed. For example, there may be a policy stored as part ofthe metadata that may specify how the data table may be partitioned intocolumn chunks and how the column chunks may be distributed amongmultiple storage servers in the column chunk data store. In oneembodiment, the policy may specify the number of partitions into which acolumn should be divided. In various embodiments, the policy may specifythe degree of redundancy of the column chunks for recovery upon failureof one or more storage servers.

Any policy for partitioning the data table may then be applied at step404 to create the column chunks. In an embodiment, partitioning may beperformed on the data table by first partitioning the data table intomultiple tables using range partitioning and then partitioning each ofthe multiple tables by applying column-wise partitioning. In variousother embodiments, list partitioning, hash partitioning, or combinationsof list, hash, and/or range partitioning may be applied to partition thedata table into multiple tables and then column wise partitioning may besubsequently applied to each of the multiple data tables.

Once the column chunks may be created, then data domain compression maybe applied to the column chunks at step 406. Data domain compression asused herein may mean applying a compression scheme designed to compressa specific data type. Given that values in a column of a column chunkmay usually be the same data type and/or part of a specific data domain,partitioning a data table into column chunks may advantageously allowdata in the column chunks to be compressed using a specific domain typecompression scheme. For example, if a column of a column chunk may storea date that falls within a narrow range, such as between Jan. 1, 2000and Dec. 31, 2010, the date field may be represented using the number ofdays since Jan. 1, 2000 rather than using a generic date representation.As another example, consider an address that may typically be stored asa string that may not compress well. By decomposing the address fieldinto several subfields, such as street number, street name, city, state,and zip, each subfield may be represented as a separate sub-columnhaving a specific data type that may compress well. As yet anotherexample, consider an argument list of key-value pairs that may also betypically stored as a string that may not compress well. By decomposingthe key-value pairs into separate column chunks, each column chunk mayrepresent values having a specific data type that may compress well.Such compression may be performed using range-based compression ofnumeric values, decomposing a column chunk including sub-fields intoseparate column chunks, decomposing a column chunk including key-valuepairs into separate column chunks, and so forth. After domain specificcompression may be applied to the column chunks, processing forpartitioning a data table into column chunks may be finished.

FIGS. 5A and 5B present exemplary illustrations generally depictinglogical representations of column chunks of a partitioned data tablestriped across multiple storage servers with parity for recovering fromfailure of a server. There may be any number of storage servers, such asstorage servers S1 502 and S2 506 illustrated in FIG. 5A, and S3 510 andS4 514 illustrated in FIG. 5B. A data table T1 may be first partitionedby date to create two data table such as T1.D1 and T1.D2, and thenhashing may be applied to each of these data table to create columnchunks. The storage policy may specify a redundancy level for recoveryfrom failure of a server. There may also be a distribution policy suchas column chunk striping specified in the storage policy. FIGS. 5A and5B illustrate an embodiment of column chunk striping with redundancyacross multiple servers in round robin order. For instance, hashing mayproduce 12 hashes, which may be represented as H01 through H12.Considering that data table T1.D1 may have four columns, C1 through C4,there may be 48 column chunks created with four column chunks in eachhash bucket, which may be represented as T1.D1.H01.C1, T1.D1.H01.C2,T1.D1.H01.C3, T1.D1.H01.C4, T1.D1.H02.C1 . . . T1.D1.H12.C4 asillustrated in FIGS. 5A and 5B. Additionally, parity may be calculatedby performing a bitwise XOR operation for combinations of column chunkssuch as

-   T1.D1.H04.C1^T1.D1.H05.C1^ T1.D1.H06.C1,-   T1.D1.H04.C2^T1.D1.H05.C2^ T1.D1.H06.C2,-   T1.D1.H04.C3^T1.D1.H05.C3^ T1.D1.H06.C3, and-   T1.D1.H04.C4^T1.D1.H05.C4^ T1.D1.H06.C4.

Column chunks, T1.D1.H01.C1 through T1.D1.H01.C4, may be assigned to thefirst storage server, S1 502, and stored in file system 504.Additionally, parity of column chunks, T1.D1.H04.C1^T1.D1.H05.C1^T1.D1.H06.C1 through T1.D1.H04.C4^T1.D1.H05.C4^ T1.D1.H06.C4, may alsobe assigned to the first storage server, S1 502, and stored in filesystem 504. Column chunks, T1.D1.H02.C1 through T1.D1.H02.C4 andT1.D1.H04.C1 through T1.D1.H04.C4, may be assigned to the second storageserver, S2 506, and stored in file system 508. Additionally, parity ofcolumn chunks, T1.D1.H07 C1^T1.D1.H08.C1^ T1.D1.H09.C1 throughT1.D1.H07.C4^T1.D1.H08.C4^ T1.D1.H09.C4, may also be assigned to thesecond storage server, S2 506, and stored in file system 508. Columnchunks, T1.D1.H03.C1 through T1.D1.H03.C4 and T1.D1.H05.C1 throughT1.D1.H05.C4, may be assigned to the third storage server, S3 510, andstored in file system 512. Additionally, parity of column chunks,T1.D1.H10.C1^T1.D1.H11.C1^ T1.D1.H12.C1 throughT1.D1.H10.C4^T1.D1.H11.C4^ T1.D1.H12.C4, may also be assigned to thethird storage server, S3 510, and stored in file system 512. Columnchunks, T1.D1.H06.C1 through T1.D1.H06.C4, may be assigned to the fourthstorage server, S4 514, and stored in file system 516. Additionally,parity of column chunks, T1.D1.H01.C1^T1.D1.H02.C1^ T1.D1.H03.C1 throughT1.D1.H01.C4^T1.D1.H02.C4^ T1.D1.H03.C4, may also be assigned to thefourth storage server, S4 514, and stored in file system 516.

Then column chunks T1.D1.H07.C1 through T1.D1.H07.C4 may be assigned tothe third storage server, S3 510, and stored in file system 512. Next,column chunks T1.D1.H08.C1 through T1.D1.H08.C4 and T1.D1.H10.C1 throughT1.D1.H10.C4 may be assigned to the fourth storage server, S4 514, andstored in file system 516. Column chunks T1.D1.H09.C1 throughT1.D1.H09.C4 and T1.D1.H11.C1 through T1.D1.H11.C4 may be assigned tothe first storage server, S1 502, and stored in file system 504.Finally, column chunks T1.D1.H12.C1 through T1.D1.H12.C4 may be assignedto the second storage server, S2 506, and stored in file system 508.

Similarly, there may be 48 column chunks created for data table T1.D2with four column chunks in each of 12 hash buckets, which may berepresented as T1.D2.H01.C1, T1.D2.H01.C2, T1.D2.H01.C3, T1.D2.H01.C4,T1.D2.H02.C1 . . . T1.D2.H12.C4. These 48 column chunks may likewise bedistributed across multiple servers using column chunk striping withredundancy in round robin order as illustrated in FIGS. 5A and 5B.

After the data tables may be partitioned, distributed and stored in thecolumn chunks data store, one or more storage servers may be removedfrom the existing storage servers of the column chunks data store. FIG.6 presents a flowchart generally representing the steps undertaken inone embodiment for removing a storage server in the column chunk datastore. At step 602, an indication may be received to remove a storageserver from the existing storage servers of the column chunk data store.For example, an indication may be received to remove storage server S4from the existing storage servers S1 through S4. In an embodiment,metadata describing the configuration of a storage server may be changedto indicate that the storage server should be removed from the existingstorage servers of the column chunk data store.

Upon receiving an indication to remove a storage server, metadata fordistributing column chunks among the remaining storage servers may beupdated at step 604. In an embodiment, a storage policy that may specifyassigning column chunks to the storage server to be removed may beupdated by removing that storage server from the list of storage serversto be used for storing column chunks. For instance, after receiving anindication to remove storage server S4 from the column chunk data store,the storage policy for data table T1 and the storage policy for datatable T2 may be updated to specify distributing the column chunks acrossservers S1 through S3, instead of distributing the column chunks acrossservers S1 through S4 as may be previously specified. In addition tospecifying how column chunks may be distributed among multiple storageservers in the column chunk data store, a storage policy may alsospecify the level of redundancy of the column chunks for recovery uponfailure of one or more storage servers. If the number of storage serversremaining after removal of a storage server may no longer be greaterthan the number of column chunks used to compute a parity column chunk,then parity for column chunks may be recalculated as described below inmore detail in conjunction with FIG. 7.

Once the metadata for distributing column chunks among the remainingstorage servers may be updated, column chunks stored on the storageserver to be removed may then be redistributed among the remainingstorage servers at step 606 as may be specified by a storage policy inthe updated metadata. After column chunks may be redistributed among theremaining storage servers, the storage server may be removed at step608. In an embodiment, the metadata for configuring the storage servermay indicate the server has a status of offline. Upon removing a storageserver in the column chunk data store, processing may be finished.

Where the number of storage servers remaining after removal of a storageserver may no longer be greater than the number of column chunks used tocompute a parity column chunk, then the parity of column chunks may berecomputed. FIG. 7 presents a flowchart generally representing the stepsundertaken in one embodiment for recomputing parity of column chunks fora specified level of redundancy upon removal of a storage server in thecolumn chunk data store. At step 702, a storage policy may be accessedto determine whether to recomputed parity of column chunks upon removalof a storage server. For example, the storage policy may specify a levelof redundancy for recovery from failure of one server in the columnchunk data store and parity of column chunks may be computed using threecolumn chunks for the column chunks stored in the column chunk datastore.

It may be determined at step 704 whether any level of redundancy hasbeen specified in the storage policy. If so, then it may be determinedat step 706 whether to recompute the parity of column chunks to providethe level of redundancy specified in the storage policy that may besupported by the remaining storage servers after removal of a storageserver. For instance, the number of column chunks used to compute aparity column chunk may be one less than the number of servers used tostore the column chunks. If the number of column chunks used to computethe existing parity column chunks is greater than one less than thenumber of remaining storage servers that may be used to store the columnchunks, then it may be determined to recompute the parity of columnchunks. If it may be determined to recompute the parity of column chunksat step 706, then the parity of the column chunks may be calculated atstep 708 for the level of redundancy specified in the storage policy. Inan embodiment, the number of column chunks used to compute the paritycolumn chunks may be one less than the number of remaining storageservers that may be used to store the column chunks. Upon calculatingthe parity column chunks at step 708, the storage policy may be updatedat step 710 to indicate the number of column chunks used to computeparity to achieve the level of redundancy specified.

Once the storage policy may be updated at step 710 or if it may bedetermined that a level of redundancy may not be specified by the policyat step 704 or if it may be determined that the parity of column chunksshould not be recomputed at step 706, then the column chunks, includingany parity column chunks previously created, may be assigned to storageservers at step 712 according to the storage policy. For instance, ifthe storage policy may specify redundancy to recover from the failure ofa server, then the column chunks and parity column chunks may beassigned as illustrated below in FIGS. 8A and 8B. After the columnchunks and any parity column chunks may be assigned to storage servers,the assignment of the column chunks to the storage servers may bereturned at step 714. When the assignment of the column chunks to thestorage servers has been returned, processing for recomputing the parityof column chunks for the level of redundancy of column chunks that maybe supported in the column chunk data store upon removal of a storageserver is finished.

FIGS. 8A and 8B present exemplary illustrations generally depictinglogical representations of column chunks of a partitioned data tablestriped across multiple storage servers after removal of a storageserver. After data table T1 may be partitioned, distributed and storedacross storage servers S1 502 through S4 514 as illustrated in FIGS. 5Aand 5B, a storage server may be removed from the column chunks datastore such as storage server S4. The metadata for data table T1 and datatable T2 may be updated to specify distributing the column chunks acrossservers S1 through S3, instead of distributing the column chunks acrossservers S1 through S4 as may have been previously specified.Accordingly, column chunks from partitioned data tables T1.D1 and T1.D2may then be redistributed among the multiple storage servers asspecified by the storage policy in the updated metadata. The storagepolicy may specify a level of redundancy of the column chunks forrecovery upon failure of one storage server. Considering that theremoval of a storage server may still leave enough storage serversremaining to support the level of redundancy specified, the level ofredundancy may be provided by recalculating the parity for the columnchunks and then redistributing the column chunks so that a parity columnchunk and any column chunk used to compute that parity column chunk maynot be stored on the same storage server. Since there may be threeservers remaining, parity column chunks may be recalculated byperforming a bitwise XOR operation on two column chunks to create aparity column chunk instead of using three column chunks as donepreviously when there were four servers available. FIGS. 8A and 8B mayillustrate an embodiment of redistributing the column chunks frompartitioned data tables T1.D1 and T1.D2 so that these column chunks maybe striped in round robin order with redundancy for recovery of a failedserver across storage servers S1 through S3.

First of all, the column chunks created for partitioned data table T1.D1and parity column chunks created may be redistributed so that thesecolumn chunks may be striped in round robin order across storage serversS1 through S3. Specifically, column chunks T1.D1.H01.Cl throughT1.D1.H01.C4, T1.D1.H06.C1 through T1.D1.H06.C4, T1.D1.H07.C1 throughT1.D1.H07.C4, T1.D1.H12.C1 through T1.D1.H12.C4, and parity columnchunks T1.D1.H03.C1^T1.D1.H04.C1 through T1.D1.H03.C4^T1.D1.H04.C4 andT1.D1.H09.C1^T1.D1.H10.C1 through T1.D1.H09.C4^T1.D1.H10.C4 may beassigned to the first storage server, S1 502, and stored in file system504. Column chunks T1.D1.H02.C1 through T1.D1.H02.C4, T1.D1.H03.C1through T1.D1.H03.C4, T1.D1.H08.C1 through T1.D1.H08.C4, T1.D1.H09.C1through T1.D1.H09.C4, and parity column chunks T1.D1.H05.C1^T1.D1.H06.C1through T1.D1.H05.C4^T1.D1.H06.C4 and T1.D1.H11.C1^T1.D1.H12.C1 throughT1.D1.H11.C4^T1.D1.H12.C4 may be assigned to the second storage server,S2 506, and stored in file system 508. And column chunks T1.D1.H04.C1through T1.D1.H04.C4, T1.D1.H05.C1 through T1.D1.H05.C4, T1.D1.H10.C1through T1.D1.H10.C4, T1.D1.H11.C1 through T1.D1.H11.C4, and paritycolumn chunks T1.D1.H01.C1^T1.D1.H02.C1 throughT1.D1.H01.C4^T1.D1.H02.C4 and T1.D1.H07.C1^T1.D1.H08.C1 throughT1.D1.H07.C4^T1.D1.H08.C4 may be assigned to the third storage server,S3 510, and stored in file system 512.

Similarly, the column chunks created for partitioned data table T1.D2and parity column chunks created may be redistributed so that thesecolumn chunks may be striped in round robin order across storage serversS1 through S3. For example, column chunks T1.D2.H01.C1 throughT1.D2.H01.C4, T1.D2.H06.C1 through T1.D2.H06.C4, T1.D2.H07.C1 throughT1.D2.H07.C4, T1.D2.H12.C1 through T1.D2.H12.C4, and parity columnchunks T1.D2.H03.C1^T1.D2.H04.C1 through T1.D2.H03.C4^T1.D2.H04.C4 andT1.D2.H09.C1^T1.D2.H10.C1 through T1.D2.H09.C4^T1.D2.H10.C4 may beassigned to the first storage server, S1 502, and stored in file system504. Column chunks T1.D2.H02.C1 through T1.D2.H02.C4, T1.D2.H03.C1through T1.D2.H03.C4, T1.D2.H08.C1 through T1.D2.H08.C4, T1.D2.H09.C1through T1.D2.H09.C4, and parity column chunks T1.D2.H05.C1^T1.D2.H06.C1through T1.D2.H05.C4^T1.D2.H06.C4 and T1.D2.H11.C1^T1.D2.H12.C1 throughT1.D2.H11.C4^T1.D2.H12.C4 may be assigned to the second storage server,S2 506, and stored in file system 508. And column chunks T1.D2.H04.C1through T1.D2.H04.C4, T1.D2.H05.C1 through T1.D2.H05.C4, T1.D2.H10.C1through T1.D2.H10.C4, T1.D2.H11.C1 through T1.D2.H11.C4, and paritycolumn chunks T1.D2.H01.C1^T1.D2.H02.C1 throughT1.D2.H01.C4^T1.D2.H02.C4 and T1.D2.H07.C1^T1.D2.H08.C1 throughT1.D2.H07.C4^T1.D2.H08.C4 may be assigned to the third storage server,S3 510, and stored in file system 512.

To redistribute the column chunks for partitioned data tables T1.D1 andT1.D2, column chunks may be moved from storage servers S1 through S4 asillustrated in FIGS. 5A and 5B to storage servers S1 through S3 asillustrated in FIGS. 8A and 8B. For example, T1.D1.H03.C1 throughT1.D1.H03.C4 and T1.D2.H03.C1 through T1.D2.H03.C4 may be moved fromstorage server S3 as illustrated in FIG. 5B to storage server S2 asillustrated in FIG. 8A. By so moving column chunks for partitioned datatables T1.D1 and T1.D2, the column chunks previously stored on serversS1 through S4 may be redistributed so that they may be striped acrossservers S1 through S3 along with the new parity column chunks createdbefore removal of storage server S4. Those skilled in the art willappreciate that these column chunks may also be redistributeddifferently in various other embodiments, including embodiments where adifferent number of storage servers have been removed.

Thus the present invention may flexibly support removing a storageserver in a distributed column chunk data store. By changing the storagepolicy for column chunks of partitioned data tables, the column chunksmay be redistributed accordingly among the remaining storage servers.Moreover, the same level of redundancy may be achieved if there are asufficient number of remaining servers by recomputing the parity ofcolumn chunks. As long as there is sufficient storage available forstoring additional parity column chunks on the remaining storageservers, recomputing the parity of column chunks may advantageouslysupport providing the same level of redundancy in the event a storageserver may be removed.

As can be seen from the foregoing detailed description, the presentinvention provides an improved system and method for removing a storageserver in a distributed column chunk data store. Any data table may beflexibly partitioned into column chunks by applying various partitioningmethods using one or more columns as a key, including rangepartitioning, list partitioning, hash partitioning, and/or combinationsof these partitioning methods. Furthermore, domain specific compressionmay be applied to a column chunk to reduce storage requirements ofcolumn chunks and decrease transmission delays for transferring columnchunks between storage servers. Storage servers may then be easilyremoved in the distributed column chunk data store and column chunks maybe flexibly redistributed among the remaining storage servers. Such asystem and method support storing detailed data needed by data mining,segmentation and business intelligence applications over long periods oftime. As a result, the system and method provide significant advantagesand benefits needed in contemporary computing, and more particularly indata mining and business intelligence applications.

While the invention is susceptible to various modifications andalternative constructions, certain illustrated embodiments thereof areshown in the drawings and have been described above in detail. It shouldbe understood, however, that there is no intention to limit theinvention to the specific forms disclosed, but on the contrary, theintention is to cover all modifications, alternative constructions, andequivalents falling within the spirit and scope of the invention.

1. A computer-implemented method for removing a storage server in adistributed system, comprising: removing a storage server operablycoupled to one or more storage servers storing column chunks of apartitioned data table; updating metadata for distributing the columnchunks stored on the storage server among the one or more storageservers; and migrating some of the column chunks among the storageserver and the one or more storage servers.
 2. The method of claim 1wherein updating metadata for distributing the column chunks stored onthe storage server comprises updating a storage policy that specifies adistribution scheme for assigning a column chunk to the one or morestorage servers.
 3. The method of claim 1 wherein updating metadata fordistributing the column chunks stored on the storage server comprisesupdating a storage policy that specifies a redundancy level for recoveryfrom failure of a storage server.
 4. The method of claim 1 whereinupdating metadata for distributing the column chunks stored on thestorage server comprises determining whether to recompute parity of thecolumn chunks.
 5. The method of claim 1 wherein migrating some of thecolumn chunks among the storage server and the one or more storageservers comprises moving at least one of the column chunks from thestorage server to one storage server of the one or more storage servers.6. The method of claim 1 wherein migrating some of the column chunksamong the storage server and the one or more storage servers comprisesmoving at least one of the column chunks stored on one storage server ofthe one or more storage servers to another storage server of the one ormore storage servers.
 7. The method of claim 1 wherein migrating some ofthe column chunks among the storage server and the one or more storageservers comprises creating new parity column chunks for a redundancylevel specified in a storage policy for recovery from failure of astorage server.
 8. The method of claim 7 further comprising storing thecolumn chunks used to create a new parity column chunk on a differentstorage server than the storage server used for storing the new paritycolumn chunk.
 9. A computer-readable storage medium havingcomputer-executable instructions for performing the method of claim 1.10. A computer-implemented method for removing a storage server in adistributed system, comprising: removing a storage server operablycoupled to one or more storage servers storing column chunks of apartitioned data table; updating metadata for distributing the columnchunks stored on the storage server among the one or more storagesewers; determining whether to recompute parity of the column chunks;and moving the column chunks stored on the storage server to the one ormore storage servers.
 11. The method of claim 10 further comprisingcomputing new parity column chunks for the column chunks.
 12. The methodof claim 11 further comprising assigning a storage server for storingeach of the column chunks.
 13. The method of claim 12 further comprisingassigning a different storage server for storing a new parity columnchunk than the storage servers assigned for storing the column chunksused to create the new parity column chunk.
 14. A computer-readablestorage medium having computer-executable instructions for performingthe method of claim
 10. 15. A distributed computer system for storingdata tables, comprising: means for removing a storage server operablycoupled to one or more storage servers storing column chunks of apartitioned a data table; means for updating metadata for distributingthe column chunks stored on the storage server among the one or morestorage servers; and means for migrating some of the column chunks amongthe storage server and the one or more storage servers.
 16. Thedistributed computer system of claim 15 further comprising means fordetermining whether to recompute parity of the column chunks.
 17. Thedistributed computer system of claim 15 further comprising means forrecomputing parity of the column chunks.
 18. The distributed computersystem of claim 17 further comprising means for storing a recomputedparity column chunk on a different storage server than the storageservers storing the column chunks used to compute the recomputed paritycolumn chunk.
 19. The distributed computer system of claim 15 whereinmeans for migrating some of the column chunks among the storage serverand the one or more storage servers comprises means for moving columnchunks stored on the storage server to the one or more storage servers.20. The distributed computer system of claim 15 wherein means formigrating some of the column chunks among the storage server and the oneor more storage server comprises means for moving at least one of thecolumn chunks stored on one storage server of the one or more storageservers to another storage sewer of the one or more storage servers.